///*
// * ConceptualRentalDAO.java
// *
// * Created on March 28, 2007, 10:07 AM
// *
// * To change this template, choose Tools | Template Manager
// * and open the template in the editor.
// */
//
//package edu.byu.isys413.samlam;
//
//import java.sql.*;
//
///**
// * Extends the FeeDAO and handles database interaction for ConceptualRental revenue source objects
// * @author Nick
// */
//public class ConceptualRentalDAO extends ConceptualDAO{
//    
//    private static ConceptualRentalDAO instance;
//    /** Creates a new instance of ConceptualRentalDAO */
//    private ConceptualRentalDAO() {
//        super();
//    }
//    
//    //Singleton pattern
//    public static synchronized ConceptualRentalDAO getInstance() {
//        if (instance == null) {
//            instance = new ConceptualRentalDAO();
//        }
//        return instance;
//    }
//    
//    /////////////////////////////////
//    ///   CREATE
//    
//    /**
//     * There's no need for two creates because we don't need
//     * a connection to create BOs.  We run the insert statement
//     * later, when it get's saved for the first time.
//     */
//    public ConceptualRental create() {
//        ConceptualRental conceptualRental = null;
//        try{
//            String id = GUID.generate();
//            conceptualRental = new ConceptualRental(id);
//            Cache cache = Cache.getInstance();
//            cache.put(conceptualRental.getId(), conceptualRental);
//            
//        }catch(Exception e){
//            e.printStackTrace();
//        }
//        return (ConceptualRental)conceptualRental;
//    }
//    
//    
//    /////////////////////////////////////
//    ///   READ
//    
//    /**
//     * This is the public read statement.  It loads an existing record
//     * from the database.
//     */
//    public synchronized ConceptualRental read(String id) throws DataException {
//        // check to see if id in the cache
//        ConceptualRental conceptualRental = (ConceptualRental)Cache.getInstance().get(id);
//        if(conceptualRental != null){
//            // if so, return it immediately
//            return (ConceptualRental)conceptualRental;
//        }
//        
//        
//        
//        Connection conn = null;
//        try {
//            // retrieve a database connection from the pool
//            conn = ConnectionPool.getInstance().get();
//            // call read with a connection (the other read method in this class)
//            conceptualRental = ConceptualRentalDAO.getInstance().read(id, conn);
//            
//            // release the connection
//            conn.commit();
//            ConnectionPool.getInstance().release(conn);
//            
//        }catch (ConnectionPoolException e4){
//            throw new DataException("Could not get a connection to the database.");
//            
//        }catch (SQLException e) {
//            // rollback
//            try{
//                conn.rollback();
//                ConnectionPool.getInstance().release(conn);
//            }catch(SQLException e2){
//                throw new DataException("Big error: could not even release the connection", e2);
//            }catch (ConnectionPoolException e3){
//                throw new DataException("Could not get a connection to the database.");
//                
//            }
//            throw new DataException("Could not retrieve record for id=" + id, e);
//        }
//        
//        // return object
//        return conceptualRental;
//    }
//    
//    /**
//     *  This is a package method that is called by the public read (above) or
//     *  by another DAO.  Either way we already have a connection to the database
//     *  to use.  The user (controller) code never calls this one directly, since
//     *  it can't know about Connection objects or SQLExceptions.
//     */
//    public synchronized ConceptualRental read(String id, Connection conn) throws SQLException, DataException {
//        // check again if the id is in the cache, and if so,
//        // just get it from the cache.  we need to check again
//        // because this method might be called directly from
//        // another DAO rather than from read above.
//        ConceptualRental conceptualRental = (ConceptualRental)Cache.getInstance().get(id);
//        if(conceptualRental != null){
//            return conceptualRental;
//        }
//        // if not in the cache, get a result set from
//        // a SELECT * FROM table WHERE id=guid
//        //query the database
//        Statement stmt = conn.createStatement();
//        ResultSet rs = stmt.executeQuery("SELECT * FROM ConceptualRental WHERE conceptualRentalid = '"+ id + "'");
//        
//        
//        if (rs.next()) {
//        //call sets from the result set
//        conceptualRental.setId(rs.getString("id"));
//        conceptualRental.setPricePerDay(rs.getDouble("pricePerDay"));
//        conceptualRental.setReplacementPrice(rs.getDouble("replacementPrice"));
//        conceptualRental.setMaxTimesRented(rs.getInt("maxTimesRented"));
//        conceptualRental.setLateFeePerDay(rs.getDouble("lateFeePerDay"));
//        Cache.getInstance().put(conceptualRental.getId(), conceptualRental);
//        super.read(rs.getString("id"), conn);
//        
//        conceptualRental.setObjectAlreadyInDB(true);
//        
//        
//        // save to the cache
//        Cache.getInstance().touch(conceptualRental.getId());
//        stmt.close();
//        }else{
//            throw new DataException("Object was not found in the database.");
//            
//        }
//        // return the BO
//        return conceptualRental;
//    }
//    
//    //////////////////////////////////
//    ///   UPDATE
//    
//    /**
//     * This is the public save method.  It is what is called when
//     * the user (controller) code wants to save or update an object
//     * into the database.
//     */
//    public synchronized void save(ConceptualRental conceptualRental) throws DataException {
//        Connection conn = null;
//        try {
//            // retrieve a database connection from the pool
//            conn = ConnectionPool.getInstance().get();
//            // call save with a connection (the other save method in this class)
//            this.save((ConceptualRental)conceptualRental, conn);
//            // release the connection
//            conn.commit();
//            ConnectionPool.getInstance().release(conn);
//        }catch (ConnectionPoolException e4){
//            throw new DataException("Could not get a connection to the database.");
//        }catch (SQLException e) {
//            // rollback
//            try {
//                conn.rollback();
//                ConnectionPool.getInstance().release(conn);
//            }catch (ConnectionPoolException e4){
//                throw new DataException("Could not get a connection to the database.");
//            }catch (SQLException e2) {
//                throw new DataException("Big error: could not even release the connection", e2);
//            }
//            
//            throw new DataException("Could not retrieve record for id=" + conceptualRental.getId(), e);
//        }
//    }
//    
//    
//    /**
//     *  This is a package method that is called by the public save (above) or
//     *  by another DAO.  Either way we already have a connection to the database
//     *  to use.  The user (controller) code never calls this one directly, since
//     *  it can't know about Connection objects or SQLExceptions.
//     *
//     *  By having other DAOs call this save method (rather than update or
//     *  insert below, each DAO in a chained save (like the ConceptualRentalDAO calling
//     *  MembershipDAO calling InterestDAO save chain) can independently decide
//     *  whether to udpate or insert the BO it's saving.  That's why I made
//     *  update and insert private rather than package level -- if you call
//     *  them directly from another DAO, this DAO can't decide whether it's
//     *  object needs to be inserted or updated.
//     */
//    synchronized void save(ConceptualRental conceptualRental, Connection conn) throws SQLException, DataException {
//        // check the dirty flag in the object.  if it is dirty,
//        // run update or insert
//        if (conceptualRental.isDirty()) {
//            
//            if (conceptualRental.isObjectAlreadyInDB() == true) {
//                update(conceptualRental, conn);
//            }else{
//                insert(conceptualRental, conn);
//            }
//            super.save(conceptualRental, conn);
//            // set the dirty flag to false now that we've saved it
//            conceptualRental.setDirty(false);
//            
//        }
//        
//        // touch the cache for the object
//        Cache.getInstance().touch(conceptualRental.getId());
//    }
//    
//    /**
//     * This method is really a part of save(bo, conn) above.  It could be
//     * embedded directly in it, but I've separated it into it's own method
//     * to isolate the SQL udpate statement and make it more readable.  But
//     * logically, it's really just a part of save.
//     */
//    private synchronized void update(ConceptualRental conceptualRental, Connection conn) throws SQLException, DataException {
//        // do the update statement
//        Statement stmt = conn.createStatement();
//        stmt.executeUpdate("UPDATE ConceptualRental set conceptualRentalid='"+conceptualRental.getId()+"', pricePerDay='"+conceptualRental.getPricePerDay()+"', replacementPrice='"+conceptualRental.getReplacementPrice()+"', maxTimesRented='"+conceptualRental.getMaxTimesRented()+"', lateFeePerDay='"+conceptualRental.getLateFeePerDay()+"' WHERE lateID='"+conceptualRental.getId()+"'");
//        stmt.close();
//    }
//    
//    /**
//     * This method is really a part of save(bo, conn) above.  It could be
//     * embedded directly in it, but I've separated it into it's own method
//     * to isolate the SQL insert statement and make it more readable.  But
//     * logically, it's really just a part of save.
//     */
//    private synchronized void insert(ConceptualRental conceptualRental, Connection conn) throws SQLException, DataException {
//        // do the insert SQL statement
//        Statement stmt = conn.createStatement();
//        stmt.executeUpdate("INSERT INTO ConceptualRental VALUES ('"+conceptualRental.getId()+"', '"+conceptualRental.getPricePerDay()+"', '"+conceptualRental.getReplacementPrice()+"', '"+conceptualRental.getMaxTimesRented()+"', '"+conceptualRental.getLateFeePerDay());
//        stmt.close();
//    }
//    
//    
//    ////////////////////////////////////
//    ///   DELETE
//    // we are not supporting because we never want to delete the ConceptualRental from
//    // our database.
//    
//    
//    
//    //////////////////////////////
//    ///  SEARCH methods
//    
//    
//}
